package com.itfenghuang.day08;

import java.util.ArrayList;
import java.util.LinkedList;

public class A03_泛型 {
    /*
        1.数组和集合的区别
            1).数组的长度不可变,集合可变
            2).数组只能存储相同类型的数据,集合可以存储不同类型的数据
            3).数组既可以存储基本数据类型,也可以存储引用数据类型的数据
                集合只能存储引用数据类型的数据
        2.泛型:
                参数化的类型     象传递参数一样传递数据类型
        3.优点:避免了强制类型的转换
        4.分类:
            1).泛型类 方法 接口
               泛型类:  格式 :修饰符 class 类名<类型>{}
                        类型:T,E
               泛型方法: 格式 : 修饰符<类型> 返回值类型  方法名(类型 变量名){}
               泛型接口: 格式 : interface 接口名<T>{}
        5.泛型的通配符
            1).泛型上线:
                    格式: ? extends 类型名
                        传递的泛型范围可以是类型名的类或子类
            2).泛型下线
                    格式: ? super 类型名
                        传递的泛型范围可以是类型名的父类或子类
     */
    public static void main(String[] args) {
        ArrayList<String> xx = new ArrayList();
        xx.add("凸(艹皿艹 )");
        xx.add("凸");
        xx.add("凹 )");
        xx.add("肏");
        System.out.println(xx.get(0));
        LinkedList<Integer> cc = new LinkedList<>();
        cc.add(12);
        System.out.println(cc);
        A<String> a = new A<>();
        a.show("12");

        B b = new B();
        b.show("哈哈哈");
//泛型上限
        ArrayList<Number> list = new ArrayList<>();
        menth(list);

//        测试泛型下限
        menth1(list);
    }
//    泛型上限
    public static void menth(ArrayList<? extends Number>list){
        for (int i = 0; i < list.size(); i++) {
            Number number = list.get(i);
            System.out.println(number);
        }
    }
    //    泛型下限
    public static void menth1(ArrayList<? super Number>list){

        }
    }
//    泛型类
class A<T>{
    public void show(T t){
        System.out.println("凸(艹皿艹 )"+t);
    }
}
//泛型接口
interface Inter<T>{
    void show(T t);
}
class B implements Inter<String>{


    @Override
    public void show(String s) {

    }
}